Today's sophisticated SoC (System on Chip) designs are rapidly evolving and nearly doubling in size with each generation. Indeed, complex designs have nearly exceeded 50 million gates. This complexity, combined with the use of devices in industrial and mission-critical products, has made complete design verification an essential element in the semiconductor development cycle. Ultimately, this means that every chip designer, system integrator, and application software developer must focus on design verification.
Hardware emulation provides an effective way to increase verification productivity, speed up time-to-market, and deliver greater confidence in the final SoC product. Even though individual intellectual property blocks may be exhaustively verified, previously undetected problems appear when the blocks are integrated within the system. Comprehensive system-level verification, as provided by hardware emulation, tests overall system functionality, IP subsystem integrity, specification errors, block-to-block interfaces, boundary cases, and asynchronous clock domain crossings. Although design reuse, intellectual property, and high-performance tools all help by shortening SoC design time, they do not diminish the system verification bottleneck, which consumes 60-70% of the design cycle. As a result, designers can implement a number of system verification strategies in a complementary methodology including software simulation, simulation acceleration, hardware emulation, and rapid prototyping. But, for system-level verification, hardware emulation remains a favorable choice due to superior performance, visibility, flexibility, and accuracy.
A short history of hardware emulation is useful for understanding the emulation environment. Initially, software programs would read a circuit design file and simulate the electrical performance of the circuit very slowly. To speed up the process, special computers were designed to run simulators as fast as possible. IBM's Yorktown “simulator” was the earliest (1982) successful example of this—it used multiple processors running in parallel to run the simulation. Each processor was programmed to mimic a logical operation of the circuit for each cycle and may be reprogrammed in subsequent cycles to mimic a different logical operation. This hardware ‘simulator’ was faster than the current software simulators, but far slower than the end-product ICs. When Field Programmable Gate Arrays (FPGAs) became available in the mid-80's, circuit designers conceived of networking hundreds of FPGAs together in order to map their circuit design onto the FPGAs and the entire FPGA network would mimic, or emulate, the entire circuit. In the early 90's the term “emulation” was used to distinguish reprogrammable hardware that took the form of the design under test (DUT) versus a general purpose computer (or work station) running a software simulation program.
Soon, variations appeared. Custom FPGAs were designed for hardware emulation that included on-chip memory (for DUT memory as well as for debugging), special routing for outputting internal signals, and for efficient networking between logic elements. Another variation used custom IC chips with networked single bit processors (so-called processor based emulation) that processed in parallel and usually assumed a different logic function every cycle.
Physically, a hardware emulator resembles a large server. Racks of large printed circuit boards are connected by backplanes in ways that most facilitate a particular network configuration. A workstation connects to the hardware emulator for control, input, and output.
Before the emulator can emulate a DUT, the DUT design must be compiled. That is, the DUT's logic must be converted (synthesized) into code that can program the hardware emulator's logic elements (whether they be processors or FPGAs). Also, the DUT's interconnections must be synthesized into a suitable network that can be programmed into the hardware emulator. The compilation is highly emulator specific and can be time consuming.
Once the design is loaded and running in the hardware emulator, it is desirable to obtain trace data of the states of the various design state elements and/or other design elements and/or design signals. Such trace data, also known as user visibility data, is made available to the user and is often used to debug a design. Unfortunately, as the number of state elements increases, so to does the amount of trace data. For example, an FPGA emulating one hundred thousand state elements could generate up to one hundred thousand bits, or 0.1 Mb, of trace data per clock cycle.
The elements that are traced can be divided into three main categories: flip-flops, glue logic, and RAM. Each of these categories has its own unique tracing problems, but all are limited by the size of a trace buffer into which data is stored. Because of the large amount of data needed to be captured over a large number of clock cycles, some elements are captured only at pre-determined intervals (e.g., every 1000 clock cycles) and if a user requests to view a particular interval, any uncaptured cycles can be simulated and regenerated in order to complete the entire trace period. For example, flip-flops may be captured once every 1000 cycles and that captured data may be used to simulate the other flip-flop states as well as the glue logic.
While such simulation works well with flip-flops and glue logic, memory must be captured every clock cycle. For example, a user wanting to view the contents of memory at a particular trace cycle cannot rely on simulation generated using a memory captured only once every 1000 cycles. If the memory contents change every cycle, such changes will be lost and unrecoverable. Another difficult issue with memory is the manner of tracing used. During emulation, the memory is constantly accessed. In order to view the memory, it is not possible to switch off the memory or the emulator and download the memory contents. Thus, current systems monitor the memory ports in order to trace changes that occurred in the memory, similar to shadow memories known in the art. Knowledge of the original contents of memory and how it changed can be used to accurately recreate the memory contents.
A problem with tracing read ports is that every user cycle, memory data continuously accumulates until a cross-over point where the data captured to duplicate the memory exceeds the memory size itself. Continued tracing beyond the cross-over point means that it would have been more efficient to have a duplicate memory. Additionally, as user designs continue to become larger and more complex, the memory size is increasing, requiring the trace buffer to monitor more memory ports. With this trend continuing, it is desirable to re-think how memory can be more efficiently traced without over-burdening the trace system.